A feedback (closed-loop) control system 100, as shown in Prior Art FIG. 1, is widely used to modify the behavior of a physical process, denoted as the plant 110, so it behaves in a specific desirable way over time. For example, it may be desirable to maintain the speed of a car on a highway as close as possible to 60 miles per hour in spite of possible hills or adverse wind; or it may be desirable to have an aircraft follow a desired altitude, heading and velocity profile independently of wind gusts; or it may be desirable to have the temperature and pressure in a reactor vessel in a chemical process plant maintained at desired levels. All these are being accomplished today by using feedback control, and the above are examples of what automatic control systems are designed to do, without human intervention.
The key component in a feedback control system is the controller 120, which determines the difference between the output of the plant 110, (e.g., the temperature) and its desired value and produces a corresponding control signal u (e.g., turning a heater on or off). The goal of controller design is usually to make this difference as small as possible as soon as possible. Today, controllers are employed in a large number of industrial control applications and in areas like robotics, aeronautics, astronautics, motors, motion control, thermal control, and so on.
Classic Controllers:
Classic Control Theory provides a number of techniques an engineer can use in controller design. Existing controllers for linear, time invariant, and single-input single output plants can be categorized into three forms: the proportional/integral/derivative (PID) controllers, transfer function based (TFB) controllers, and state feedback (SF) controllers. The PID controller is defined by the equationu=Kpe+K1∫e+KDė  (1)where u is the control signal and e is the error between the setpoint and the process output being controlled. This type of controller has been employed in engineering and other applications since the early 1920s. It is an error based controller that does not require an explicit mathematical model of the plant. The TFB controller is given in the form of
                                          U            ⁡                          (              s              )                                =                                                    G                c                            ⁡                              (                s                )                                      ⁢                          E              ⁡                              (                s                )                                                    ,                                            G              c                        ⁡                          (              s              )                                =                                    n              ⁡                              (                s                )                                                    d              ⁡                              (                s                )                                                                        (        2        )            where U(s) and E(s) are Laplace Transforms of u and e defined above, and n(s) and d(s) are polynomials in s. The TFB controller can be designed using methods in control theory based on the transfer function model of the plant, Gp(s). A PID controller can be considered a special case of a TFB controller because it has an equivalent transfer function of
                                          G            c                    ⁡                      (            s            )                          =                              k            p                    +                                    k              i                        s                    +                                    k              d                        ⁢            s                                              (        3        )            The State Feedback (SF) Controller
The SF controller can be defined byu=r+K{circumflex over (x)}  (4)and is based on the state space model of the plant:{dot over (x)}(t)=Ax(t)+Bu(t), y(t)=Cx(t)+Du(t)  (5)When the state x is not accessible, a state observer (SO):
                              x                      ^            .                          =                              A            ⁢                          x              ^                                +          Bu          +                      L            ⁡                          (                              y                -                                  y                  ^                                            )                                                          (        6        )            is often used to find its estimate, {circumflex over (x)}. Here r is the setpoint for the output to follow.
In addition to the above controllers, a more practical controller is the recently developed Active Disturbance Rejection Controller (ADRC). Its linear form (LADRC) for a second order plant is introduced below as an illustration. The unique distinction of ADRC is that it is largely independent of the mathematical model of the plant and is therefore better than most controllers in performance and robustness in practical applications.
Linear Activated Disturbance Rejection Controller (LADRC)
Consider an example of controlling a second order plantÿ=−a{dot over (y)}−by+w+bu  (7)where y and u are output and input, respectively, and w is an input disturbance. Here both parameters, a and b, are unknown, although there is some knowledge of b, (e.g., b0≈b, derived from the initial acceleration of y in step response). Rewrite (7) asÿ=−a{dot over (y)}−by+w+(b−b0)u+b0u=f+b0u  (8)where f=−a{dot over (y)}−by+w+(b−b0)u. Here f is referred to as the generalized disturbance, or disturbance, because it represents both the unknown internal dynamics, −a{dot over (y)}−by+(b−b0)u and the external disturbance w(t).
If an estimate of f, {circumflex over (f)} can be obtained, then the control law
  u  =                    -                  f          ^                    +              u        0                    b      0      reduces the plant to ÿ=(f−{circumflex over (f)})+u0 which is a unit-gain double integrator control problem with a disturbance (f−{circumflex over (f)}).
Thus, rewrite the plant in (8) in state space form as
                    {                                                                                                  x                    .                                    1                                =                                  x                  2                                                                                                                                              x                    .                                    2                                =                                                      x                    3                                    +                                                            b                      0                                        ⁢                    u                                                                                                                                                                x                    .                                    3                                =                h                                                                                        y                =                                  x                  1                                                                                        (        9        )            with x3=f added as an augmented state, and h={dot over (f)} is seen as an unknown disturbance. Now f can be estimated using a state observer based on the state space model
                                          x            .                    =                      Ax            +            Bu            +            Eh                          ⁢                                  ⁢                  y          =          Cz                ⁢                                  ⁢        where        ⁢                                  ⁢                              A            =                          [                                                                    0                                                        1                                                        0                                                                                        0                                                        0                                                        1                                                                                        0                                                        0                                                        0                                                              ]                                ,                                          ⁢                      B            =                          [                                                                    0                                                                                                              b                      0                                                                                                            0                                                              ]                                ,                                          ⁢                      C            =                          [                                                                    1                                                        0                                                        0                                                              ]                                ,                                          ⁢                      E            =                          [                                                                    0                                                                                        0                                                                                        1                                                              ]                                                          (        10        )            Now the state space observer, denoted as the linear extended state observer (LESO), of (10) can be constructed asż=Az+Bu+L(y−ŷ)ŷ=Cz  (11)
which can be reconstructed in software, for example, and L is the observer gain vector, which can be obtained using various methods known in the art like pole placement,L=[β1β2β3]T  (12)where [ ]T denotes transpose. With the given state observer, the control law can be given as:
                    u        =                                            -                              z                3                                      +                          u              0                                            b            0                                              (        13        )            Ignoring the inaccuracy of the observer,ÿ=(f−z3)+u0≈u0  (14)which is an unit gain double integrator that can be implemented with a PD controlleru0=kp(r−z1)−kdz2  (15)Controller Tuning
Over the years, the advances in control theory provided a number of useful analysis and design tools. As a result, controller design moved from empirical methods (e.g., ad hoc tuning via Ziegler and Nichols tuning tables for PID) to analytical methods (e.g., pole placement). The frequency response method (Bode and Nyquist plots) also facilitated analytical control design.
Conventionally, controllers are individually designed according to design criteria and then individually tuned until they exhibit an acceptable performance. Practicing engineers may design controllers, (e.g., PID) using look-up tables and then time the controllers using trial and error techniques. But each controller is typically individually designed, tuned, and tested.
Tuning controllers has perplexed engineers. Controllers that are developed based on a mathematical model of the plant usually need their parameters to be adjusted, or “tuned” as they are implemented in hardware and tested. This is because the mathematical model often does not accurately reflect the dynamics of the plant. Determining appropriate control parameters under such circumstances is often problematic, leading to control solutions that are functional but ill-tuned, yielding lost performance and wasted control energy. Additionally, and/or alternatively, engineers design using analytical (e.g., pole placement) techniques, but once again tune with trial and error techniques. Since many industrial machines and engineering applications are built to be inherently stable, acceptable controllers can be designed and tuned using these conventional techniques, however, acceptable performance may not approach optimal performance.
One example conventional technique for designing a Pm controller included obtaining an open-loop response and determining what, if anything, needed to be improved. By way of illustration, the designer would build a candidate system with a feedback loop, guess the initial values of the three gains (e.g., kp, kd, ki) in ND and observe the performance in terms of rise time, steady state error and so on. Then, the designer might modify the proportional gain to improve rise time. Similarly, the designer might add or modify a derivative controller to improve overshoot and an integral controller to eliminate steady state error. Each component would have its own gain that would be individually tuned. Thus, conventional designers often faced choosing three components in a PID controller and individually tuning each component. Furthermore, there could be many more parameters that the design engineer must tune if a TFB or a state feedback state observer (SFSOB) controller is employed.
Another observation of control design is that it is not portable. That is, each control problem is solved individually and its solution cannot be easily modified for another control problem. This means that the tedious design and tuning process must be repeated for each control problem.
Thus, having reviewed controllers, the application now describes example systems and methods related to controllers.